GermanWikipedia - /page/entry.mu

Micron Document

`:top

`!SQL`! (offizielle Aussprache [], mitunter auch []; auf Deutsch auch häufig die deutsche Aussprache der Buchstaben) ist eine `F33f`_`[Datenbanksprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanksprache]`_`f zur Definition von `F33f`_`[Datenstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenstruktur]`_`f in `F33f`_`[relationalen Datenbanken`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Relationale_Datenbank]`_`f sowie zum Bearbeiten (Einfügen, Verändern, Löschen) und Abfragen von darauf basierenden Datenbeständen.

Die Sprache basiert auf der `F33f`_`[relationalen Algebra`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Relationale_Algebra]`_`f, ihre `F33f`_`[Syntax`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Syntax]`_`f ist relativ einfach aufgebaut und `F33f`_`[semantisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Formale_Semantik]`_`f an die englische Umgangssprache angelehnt. Ein gemeinsames Gremium von `F33f`_`[ISO`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internationale_Organisation_für_Normung]`_`f und `F33f`_`[IEC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=International_Electrotechnical_Commission]`_`f `F33f`_`[standardisiert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Standardisierung]`_`f die Sprache unter Mitwirkung nationaler Normungsgremien wie `F33f`_`[ANSI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=American_National_Standards_Institute]`_`f oder `F33f`_`[DIN`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deutsches_Institut_für_Normung]`_`f. Durch den Einsatz von SQL strebt man die Unabhängigkeit der Anwendungen vom eingesetzten `F33f`_`[Datenbankmanagementsystem`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbank]`_`f an.

Die Bezeichnung `*SQL`* wird im allgemeinen Sprachgebrauch als Abkürzung für „`!Structured Query Language`!“ (auf Deutsch: „Strukturierte Abfrage-Sprache“) aufgefasst, obwohl sie laut Standard ein eigenständiger Name ist. Die Bezeichnung leitet sich von dem Vorgänger SEQUEL ([], Structured English Query Language) ab, welche mit Beteiligung von `F33f`_`[Edgar F. Codd`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Edgar_F._Codd]`_`f (IBM) in den 1970er Jahren von `F33f`_`[Donald D. Chamberlin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Donald_D._Chamberlin]`_`f und `F33f`_`[Raymond F. Boyce`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Raymond_F._Boyce]`_`f entwickelt wurde. SEQUEL wurde später in SQL umbenannt, weil SEQUEL ein eingetragenes Warenzeichen der `F33f`_`[Hawker Siddeley`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hawker_Siddeley]`_`f Aircraft Company war.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f]

>>Contents

• `F0af`_`[Sprachelemente und Beispiele`#sprachelemente-und-beispiele]`_`f

• `F0af`_`[Einfache Abfrage`#einfache-abfrage]`_`f

• `F0af`_`[Abfrage mit Spaltenauswahl ( , )`#abfrage-mit-spaltenauswahl]`_`f

• `F0af`_`[Abfrage mit eindeutigen Werten ( DISTINCT )`#abfrage-mit-eindeutigen-werten-distinct]`_`f

• `F0af`_`[Abfrage mit Umbenennung ( AS )`#abfrage-mit-umbenennung-as]`_`f

• `F0af`_`[Abfrage mit Filter ( WHERE )`#abfrage-mit-filter-where]`_`f

• `F0af`_`[Abfrage mit Filter nach Inhalt ( WHERE ... LIKE ... )`#abfrage-mit-filter-nach-inhalt-where-like]`_`f

• `F0af`_`[Abfrage mit Filter und Sortierung ( ORDER BY )`#abfrage-mit-filter-und-sortierung-order-by]`_`f

• `F0af`_`[Abfrage mit verknüpften Tabellen ( , und INNER JOIN )`#abfrage-mit-verkn-pften-tabellen-und-inner-join]`_`f

• `F0af`_`[Linker äußerer Verbund ( LEFT OUTER JOIN )`#linker-u-erer-verbund-left-outer-join]`_`f

• `F0af`_`[Gruppierung mit Aggregat-Funktionen ( GROUP BY )`#gruppierung-mit-aggregat-funktionen-group-by]`_`f

• `F0af`_`[Zusammenfassung eines SELECT`#zusammenfassung-eines-select]`_`f

• `F0af`_`[Einfügen von Datensätzen ( INSERT INTO ... VALUES ... )`#einf-gen-von-datens-tzen-insert-into-values]`_`f

• `F0af`_`[Ändern von Datensätzen ( UPDATE )`#ndern-von-datens-tzen-update]`_`f

• `F0af`_`[Löschen von Datensätzen ( DELETE )`#l-schen-von-datens-tzen-delete]`_`f

• `F0af`_`[Zusammenfassung von INSERT , UPDATE und DELETE`#zusammenfassung-von-insert-update-und-delete]`_`f

• `F0af`_`[Datendefinition`#datendefinition]`_`f

• `F0af`_`[Datenbanktabelle ( CREATE TABLE )`#datenbanktabelle-create-table]`_`f

• `F0af`_`[Datenbankindex ( CREATE INDEX )`#datenbankindex-create-index]`_`f

• `F0af`_`[Sicht ( CREATE VIEW )`#sicht-create-view]`_`f

• `F0af`_`[Zusammenfassung von CREATE TABLE , CREATE INDEX und CREATE VIEW`#zusammenfassung-von-create-table-create-index-und-create-view]`_`f

• `F0af`_`[Redundanz`#redundanz]`_`f

• `F0af`_`[Schlüssel`#schl-ssel]`_`f

• `F0af`_`[Referenzielle Integrität`#referenzielle-integrit-t]`_`f

• `F0af`_`[SQL-Datentypen`#sql-datentypen]`_`f

• `F0af`_`[Transaktion, Commit und Rollback`#transaktion-commit-und-rollback]`_`f

• `F0af`_`[Programmieren mit SQL`#programmieren-mit-sql]`_`f

• `F0af`_`[Programmierschnittstelle`#programmierschnittstelle]`_`f

• `F0af`_`[Statisches und dynamisches SQL`#statisches-und-dynamisches-sql]`_`f

• `F0af`_`[Chronologie`#chronologie]`_`f

• `F0af`_`[Sprachstandard`#sprachstandard]`_`f

• `F0af`_`[Erweiterungen`#erweiterungen]`_`f

• `F0af`_`[Literatur`#literatur]`_`f

• `F0af`_`[Weblinks`#weblinks]`_`f

• `F0af`_`[Siehe auch`#siehe-auch]`_`f

• `F0af`_`[Weblinks`#weblinks]`_`f

• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Sprachelemente und Beispiele

SQL-Befehle lassen sich in fünf Kategorien unterteilen (Zuordnung nach der Theorie der `F33f`_`[Datenbanksprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanksprache]`_`f in Klammern):

• `F33f`_`[Data Query Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Data_Query_Language]`_`f (DQL) – Befehle zur Abfrage und Aufbereitung der gesuchten Informationen, wird auch als Untermenge der DML klassifiziert

• `F33f`_`[Data Manipulation Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Data_Manipulation_Language]`_`f (DML) – Befehle zur `F33f`_`[Datenmanipulation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenmanipulation]`_`f (Ändern, Einfügen, Löschen von `F33f`_`[Datensätzen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datensatz]`_`f) und lesendem Zugriff

• `F33f`_`[Data Definition Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Data_Definition_Language]`_`f (DDL) – Befehle zur `F33f`_`[Definition`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datendefinition]`_`f des `F33f`_`[Datenbankschemas`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbankschema]`_`f (Erzeugen, Ändern, Löschen von `F33f`_`[Datenbanktabellen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanktabelle]`_`f, Definition von `F33f`_`[Primärschlüsseln`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Primärschlüssel]`_`f und `F33f`_`[Fremdschlüsseln`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fremdschlüssel]`_`f)

• `F33f`_`[Data Control Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Data_Control_Language]`_`f (DCL) – Befehle für die `F33f`_`[Rechteverwaltung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mehrbenutzersystem]`_`f

• `F33f`_`[Transaction Control Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Transaction_Control_Language]`_`f (TCL) – Befehle für die `F33f`_`[Transaktionskontrolle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Transaktion_(Informatik)]`_`f

Die Bezeichnung SQL bezieht sich auf das englische Wort “query” (deutsch: „`F33f`_`[Abfrage`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Abfragesprache]`_`f“). Mit Abfragen werden die in einer Datenbank gespeicherten Daten abgerufen, also dem Benutzer oder einer Anwendersoftware zur Verfügung gestellt.

Das Ergebnis einer Abfrage sieht wiederum aus wie eine Tabelle und kann oft auch wie eine Tabelle angezeigt, bearbeitet und weiterverwendet werden.

Siehe auch

Datenbanktabelle

Die grundlegenden Befehle und Begriffe werden anhand des folgenden Beispiels erklärt:

>>>Einfache Abfrage

`B100`F9d9SELECT *`f`b

`B100`F9d9 FROM Student;`f`b

listet alle Spalten und alle Zeilen der Tabelle `B100`F9d9Student`f`b auf.

Ergebnis:

| MatrNr | Name |

|---|---|

| 26120 | Fichte |

| 25403 | Jonas |

| 27103 | Fauler |

>>>Abfrage mit Spaltenauswahl ( , )

`B100`F9d9SELECT VorlNr,`f`b

`B100`F9d9 Titel`f`b

`B100`F9d9 FROM Vorlesung;`f`b

listet die Spalten `B100`F9d9VorlNr`f`b und `B100`F9d9Titel`f`b aller Zeilen der Tabelle `B100`F9d9Vorlesung`f`b auf.

Ergebnis:

| VorlNr | Titel |

|---|---|

| 5001 | ET |

| 5022 | IT |

| 5045 | DB |

>>>Abfrage mit eindeutigen Werten ( DISTINCT )

`B100`F9d9SELECT DISTINCT MatrNr`f`b

`B100`F9d9 FROM hoert;`f`b

listet nur unterschiedliche Einträge der Spalte `B100`F9d9MatrNr`f`b aus der Tabelle `B100`F9d9hoert`f`b auf. Dies zeigt die Matrikelnummern aller Studenten, die mindestens eine Vorlesung hören, wobei mehrfach auftretende Matrikelnummern nur einmal ausgegeben werden.

Ergebnis:

| MatrNr |

|---|

| 25403 |

| 26120 |

>>>Abfrage mit Umbenennung ( AS )

`B100`F9d9SELECT MatrNr AS Matrikelnummer,`f`b

`B100`F9d9 Name`f`b

`B100`F9d9 FROM Student;`f`b

listet die Spalten `B100`F9d9MatrNr`f`b und Name aller Zeilen der Tabelle `B100`F9d9Student`f`b auf. `B100`F9d9MatrNr`f`b wird beim Anzeigeergebnis als Matrikelnummer aufgeführt.

Ergebnis:

| Matrikelnummer | Name |

|---|---|

| 26120 | Fichte |

| 25403 | Jonas |

| 27103 | Fauler |

>>>Abfrage mit Filter ( WHERE )

`B100`F9d9SELECT VorlNr,`f`b

`B100`F9d9 Titel`f`b

`B100`F9d9 FROM Vorlesung`f`b

`B100`F9d9 WHERE Titel = 'ET';`f`b

listet `B100`F9d9VorlNr`f`b und `B100`F9d9Titel`f`b aller derjenigen Zeilen der Tabelle `B100`F9d9Vorlesung`f`b auf, deren Titel `B100`F9d9ET`f`b ist.

Die solchermaßen strukturierte, häufig verwendete Anweisung wird nach den Anfangsbuchstaben auch als „SFW-Block“ bezeichnet.

Ergebnis:

| VorlNr | Titel |

|---|---|

| 5001 | ET |

>>>Abfrage mit Filter nach Inhalt ( WHERE ... LIKE ... )

`B100`F9d9SELECT Name`f`b

`B100`F9d9 FROM Student`f`b

`B100`F9d9 WHERE Name LIKE 'F%';`f`b

listet die Namen aller Studenten auf, deren Name mit `B100`F9d9F`f`b beginnt (im Beispiel: `B100`F9d9Fichte`f`b und `B100`F9d9Fauler`f`b).

`B100`F9d9LIKE`f`b kann mit verschiedenen `F33f`_`[Platzhaltern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wildcard_(Informatik)]`_`f verwendet werden: `B100`F9d9_`f`b steht für ein einzelnes beliebiges Zeichen, `B100`F9d9%`f`b steht für eine beliebige Zeichenfolge. Manche Datenbanksysteme bieten weitere solcher `*Wildcard`*-Zeichen an, etwa für Zeichenmengen.

Ergebnis:

| Name |

|---|

| Fichte |

| Fauler |

>>>Abfrage mit Filter und Sortierung ( ORDER BY )

`B100`F9d9 SELECT Vorname,`f`b

`B100`F9d9 Name,`f`b

`B100`F9d9 StrasseNr,`f`b

`B100`F9d9 Plz,`f`b

`B100`F9d9 Ort`f`b

`B100`F9d9 FROM Student`f`b

`B100`F9d9 WHERE Plz = '20095'`f`b

`B100`F9d9ORDER BY Name;`f`b

listet `B100`F9d9Vorname`f`b, `B100`F9d9Name`f`b, `B100`F9d9StrasseNr`f`b, `B100`F9d9Plz`f`b und `B100`F9d9Ort`f`b aller Studenten aus dem angegebenen Postleitzahlbereich aufsteigend sortiert nach `B100`F9d9Name`f`b auf.

>>>Abfrage mit verknüpften Tabellen ( , und INNER JOIN )

`B100`F9d9SELECT Vorlesung.VorlNr,`f`b

`B100`F9d9 Vorlesung.Titel,`f`b

`B100`F9d9 Professor.PersNr,`f`b

`B100`F9d9 Professor.Name`f`b

`B100`F9d9 FROM Professor,`f`b

`B100`F9d9 Vorlesung`f`b

`B100`F9d9 WHERE Professor.PersNr = Vorlesung.PersNr;`f`b

Die Aufzählung hinter `F33f`_`[FROM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=From_(SQL)]`_`f legt die Datenquellen fest: An dieser Stelle können mit Hilfe sogenannter `F33f`_`[JOINs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Join_(SQL)]`_`f mehrere Tabellen miteinander verknüpft werden, so dass Daten aus verschiedenen Tabellen zusammengeführt und angezeigt werden.

In diesem Beispiel wird ein „innerer natürlicher Verbund“ (`B100`F9d9NATURAL INNER JOIN`f`b) verwendet: alle Datensätze aus den Tabellen `B100`F9d9Professor`f`b und `B100`F9d9Vorlesung`f`b, die den gleichen Wert im Feld `B100`F9d9PersNr`f`b haben. `B100`F9d9Professor`f`ben ohne `B100`F9d9Vorlesung`f`b und `B100`F9d9Vorlesung`f`ben ohne `B100`F9d9Professor`f`b werden damit nicht angezeigt.

Dies ist äquivalent zu:

`B100`F9d9 SELECT Vorlesung.VorlNr,`f`b

`B100`F9d9 Vorlesung.Titel,`f`b

`B100`F9d9 Professor.PersNr,`f`b

`B100`F9d9 Professor.Name`f`b

`B100`F9d9 FROM Professor`f`b

`B100`F9d9INNER JOIN Vorlesung`f`b

`B100`F9d9 ON Professor.PersNr = Vorlesung.PersNr;`f`b

`*Vorsicht: Nicht alle Implementierungen verstehen beide Schreibweisen, die `F33f`_`[Oracle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oracle]`_`f-Schreibweise `B100`F9d9FROM Professor, Vorlesung`f`b gilt als veraltet und ist weniger verbreitet. Sie entspricht auch nicht dem ANSI-Standard und sollte deshalb vermieden werden. Aus historischen Gründen ist sie jedoch noch häufig anzutreffen.`*

Tabellen können nicht nur über Schlüsselfelder, sondern über beliebige Felder miteinander verknüpft werden, wie das folgende, fachlich unsinnige Beispiel zeigt:

`B100`F9d9SELECT Vorlesung.Titel,`f`b

`B100`F9d9 Professor.Name`f`b

`B100`F9d9 FROM Professor,`f`b

`B100`F9d9 Vorlesung`f`b

`B100`F9d9 WHERE Professor.Name <> Vorlesung.Titel`f`b

Das Ergebnis enthält die Kombinationen `*aller`* `B100`F9d9Vorlesung`f`ben und `*aller `B100`F9d9Professor`f`ben`*, bei denen der Name des `B100`F9d9Professor`f`bs vom Titel der `B100`F9d9Vorlesung`f`b `*abweicht`* – das sind einfach alle (keine `B100`F9d9Vorlesung`f`b heißt wie ein `B100`F9d9Professor`f`b):

| Titel | Name |

|---|---|

| ET | Tesla |

| ET | Wirth |

| ET | Urlauber |

| IT | Tesla |

| IT | Wirth |

| IT | Urlauber |

| DB | Tesla |

| DB | Wirth |

| DB | Urlauber |

>>>Linker äußerer Verbund ( LEFT OUTER JOIN )

`B100`F9d9 SELECT Professor.PersNr,`f`b

`B100`F9d9 Professor.Name,`f`b

`B100`F9d9 Vorlesung.VorlNr,`f`b

`B100`F9d9 Vorlesung.Titel`f`b

`B100`F9d9 FROM Professor`f`b

`B100`F9d9LEFT OUTER JOIN Vorlesung`f`b

`B100`F9d9 ON Professor.PersNr = Vorlesung.PersNr;`f`b

ergibt alle Datensätze der Tabelle `B100`F9d9Professor`f`b, verbunden mit den Datensätzen der Tabelle `B100`F9d9Vorlesung`f`b, die den jeweils gleichen Wert im Feld `B100`F9d9PersNr`f`b haben. `B100`F9d9Professor`f`ben ohne Vorlesung sind im Ergebnis enthalten. Die Spalten aus der `B100`F9d9Vorlesung`f`b-Tabelle haben dann den Wert `B100`F9d9NULL`f`b. `B100`F9d9Vorlesung`f`ben ohne `B100`F9d9Professor`f`b sind nicht enthalten.

Die folgende Abfrage liefert nur diejenigen Datensätze, zu denen kein passender Datensatz im linken äußeren Verbund existiert (alle `B100`F9d9Professor`f`ben, die keine `B100`F9d9Vorlesung`f`ben halten):

`B100`F9d9 SELECT Professor.PersNr,`f`b

`B100`F9d9 Professor.Name`f`b

`B100`F9d9 FROM Professor`f`b

`B100`F9d9LEFT OUTER JOIN Vorlesung`f`b

`B100`F9d9 ON Professor.PersNr = Vorlesung.PersNr`f`b

`B100`F9d9 WHERE Vorlesung.PersNr IS NULL;`f`b

Das Gleiche kann mittels einer Unterabfrage erreicht werden:

`B100`F9d9SELECT Professor.PersNr,`f`b

`B100`F9d9 Professor.Name`f`b

`B100`F9d9 FROM Professor`f`b

`B100`F9d9 WHERE NOT EXISTS (SELECT *`f`b

`B100`F9d9 FROM Vorlesung`f`b

`B100`F9d9 WHERE PersNr = Professor.PersNr);`f`b

>>>Gruppierung mit Aggregat-Funktionen ( GROUP BY )

`B100`F9d9 SELECT Professor.PersNr,`f`b

`B100`F9d9 Professor.Name,`f`b

`B100`F9d9 COUNT(Vorlesung.PersNr) AS Anzahl`f`b

`B100`F9d9 FROM Professor`f`b

`B100`F9d9LEFT OUTER JOIN Vorlesung`f`b

`B100`F9d9 ON Professor.PersNr = Vorlesung.PersNr`f`b

`B100`F9d9 GROUP BY Professor.Name,`f`b

`B100`F9d9 Professor.PersNr;`f`b

zählt die Anzahl der `B100`F9d9Vorlesungen`f`b pro `B100`F9d9Professor`f`b mit Hilfe der `F33f`_`[Aggregat`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aggregation_(Informatik)]`_`f-Funktion `B100`F9d9COUNT`f`b.

`*Bemerkung`*: `B100`F9d9COUNT(Professor.PersNr)`f`b oder `B100`F9d9COUNT(*)`f`b wären falsch (`F33f`_`[NULL-Werte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Nullwert]`_`f sollen nicht mitgezählt werden).

>>>Zusammenfassung eines SELECT

Zusammengefasst kann man die wichtigsten Elemente einer SQL-`B100`F9d9SELECT`f`b-Abfrage etwa so beschreiben:

`B100`F9d9SELECT [DISTINCT] Auswahlliste [AS Spaltenalias]`f`b

`B100`F9d9FROM Quelle [ [AS] Tabellenalias], evtl. mit JOIN-Verknüpfungen`f`b

`B100`F9d9[WHERE Where-Klausel]`f`b

`B100`F9d9[GROUP BY ein oder mehrere Group-by-Attribute]`f`b

`B100`F9d9[HAVING Having-Klausel]`f`b

`B100`F9d9[ORDER BY ein oder mehrere Sortierungsattribute mit [ASC|DESC]];`f`b

`!Erläuterung:`!

• `!`B100`F9d9DISTINCT`f`b:`! gibt an, dass aus der Ergebnisrelation gleiche `F33f`_`[Ergebnistupel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tupel_(Informatik)]`_`f entfernt werden sollen. Es wird also jeder Datensatz nur einmal ausgegeben, auch wenn er mehrfach in der Tabelle vorkommt. Sonst liefert SQL eine `F33f`_`[Multimenge`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Multimenge]`_`f zurück.

• `!Auswahlliste:`! bestimmt, welche Spalten der `*Quelle`* auszugeben sind (`B100`F9d9*`f`b für alle) und ob `F33f`_`[Aggregatsfunktionen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aggregatfunktion]`_`f anzuwenden sind. Wie bei allen anderen Aufzählungen werden die einzelnen Elemente mit Komma (`B100`F9d9,`f`b) voneinander getrennt.

• `!Quelle:`! gibt an, wo die Daten herkommen. Es können `F33f`_`[Relationen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Relation_(Datenbank)]`_`f und `F33f`_`[Sichten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sicht_(Datenbank)]`_`f angegeben werden und miteinander als `F33f`_`[kartesisches Produkt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kartesisches_Produkt]`_`f oder als Verbund (`F33f`_`[JOIN`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Relationale_Algebra]`_`f, ab SQL-92) verknüpft werden. Mit der zusätzlichen Angabe eines Namens können Relationen für die Abfrage umbenannt werden (vgl. `F33f`_`[Beispiele`#sprachelemente-und-beispiele]`_`f).

• `!`B100`F9d9WHERE`f`b-Klausel:`! bestimmt Bedingungen, auch Filter genannt, unter denen die Daten ausgegeben werden sollen. In SQL ist hier auch die Angabe von Unterabfragen möglich, so dass SQL `*streng relational vollständig`* wird.

• `!`B100`F9d9GROUP BY`f`b-Attribut:`! legt fest, ob unterschiedliche Werte als einzelne Zeilen ausgegeben werden sollen (`B100`F9d9GROUP BY`f`b = Gruppierung) oder aber die Feldwerte der Zeilen durch Aggregationen wie Addition (`B100`F9d9SUM`f`b), Durchschnitt (`B100`F9d9AVG`f`b), Minimum (`B100`F9d9MIN`f`b), Maximum (`B100`F9d9MAX`f`b) zu einem Ergebniswert zusammengefasst werden, der sich auf die Gruppierung bezieht.

• `!`B100`F9d9HAVING`f`b-Klausel:`! ist wie die `B100`F9d9WHERE`f`b-Klausel, nur dass sich die angegebene Bedingung auf das Ergebnis einer Aggregationsfunktion bezieht, zum Beispiel `B100`F9d9HAVING SUM (Betrag) > 0`f`b.

• `!Sortierungsattribut:`! Nach `B100`F9d9ORDER BY`f`b werden Attribute angegeben, nach denen sortiert werden soll. Die Standardvoreinstellung ist `B100`F9d9ASC`f`b, das bedeutet aufsteigende Sortierung, `B100`F9d9DESC`f`b ist absteigende Sortierung.

`!Mengenoperatoren`! können auf mehrere `B100`F9d9SELECT`f`b-Abfragen angewandt werden, die gleich viele Attribute haben und bei denen die Datentypen der Attribute übereinstimmen:

• `!`B100`F9d9UNION`f`b:`! vereinigt die Ergebnismengen. In einigen Implementierungen werden mehrfach vorkommende Ergebnistupel wie bei `B100`F9d9DISTINCT`f`b entfernt, ohne dass `B100`F9d9UNION DISTINCT`f`b geschrieben werden muss beziehungsweise darf.

• `!`B100`F9d9UNION ALL`f`b:`! vereinigt die Ergebnismengen. Mehrfach vorkommende Ergebnistupel bleiben erhalten. Einige Implementierungen interpretieren aber `B100`F9d9UNION`f`b wie `B100`F9d9UNION ALL`f`b und verstehen das `B100`F9d9ALL`f`b möglicherweise nicht und geben eine Fehlermeldung aus.

• `!`B100`F9d9EXCEPT`f`b:`! liefert die Tupel, die in einer ersten, jedoch nicht in einer zweiten Ergebnismenge enthalten sind. Mehrfach vorkommende Ergebnistupel werden entfernt.

• `!`B100`F9d9MINUS`f`b:`! ein analoger Operator wie `B100`F9d9EXCEPT`f`b, der in manchen SQL-Dialekten alternativ benutzt wird.

• `!`B100`F9d9INTERSECT`f`b:`! liefert die Schnittmenge zweier Ergebnismengen. Mehrfach vorkommende Ergebnistupel werden entfernt.

>>>Einfügen von Datensätzen ( INSERT INTO ... VALUES ... )

`B100`F9d9INSERT INTO Vorlesung (VorlNr, Titel, PersNr) VALUES (1000, 'Softwareentwicklung 1', 12);`f`b

`B100`F9d9INSERT INTO Vorlesung (VorlNr, Titel, PersNr) VALUES (1600, 'Algorithmen', 12);`f`b

`B100`F9d9INSERT INTO Vorlesung (VorlNr, Titel, PersNr) VALUES (1200, 'Netzwerke 1', 20);`f`b

`B100`F9d9INSERT INTO Vorlesung (VorlNr, Titel, PersNr) VALUES (1001, 'Datenbanken', 15);`f`b

fügt vier Datensätze in die Tabelle `B100`F9d9Vorlesung`f`b ein. Die Werte müssen mit den Datentypen der Felder `B100`F9d9VorlNr`f`b, `B100`F9d9Titel`f`b und `B100`F9d9PersNr`f`b zusammenpassen.

`B100`F9d9SELECT *`f`b

`B100`F9d9 FROM Vorlesung;`f`b

liefert dann zum Beispiel das Ergebnis (die Reihenfolge kann auch anders sein):

| VorlNr | Titel | PersNr |

|---|---|---|

| 1001 | Datenbanken | 15 |

| 1000 | Softwareentwicklung 1 | 12 |

| 1200 | Netzwerke 1 | 20 |

| 5001 | ET | 12 |

| 5022 | IT | 12 |

| 1600 | Algorithmen | 12 |

| 5045 | DB | 15 |

>>>Ändern von Datensätzen ( UPDATE )

`B100`F9d9UPDATE Vorlesung`f`b

`B100`F9d9 SET VorlNr = VorlNr + 1000,`f`b

`B100`F9d9 PersNr = 20`f`b

`B100`F9d9 WHERE PersNr = 15;`f`b

ändert alle Datensätze, für die `B100`F9d9PersNr`f`b den Wert `B100`F9d915`f`b hat. Der Wert von `B100`F9d9VorlNr`f`b wird um `B100`F9d91000`f`b erhöht und der Wert von `B100`F9d9PersNr`f`b auf `B100`F9d920`f`b gesetzt.

Ergebnis eines nachfolgenden `B100`F9d9SELECT *`f`b ist, eventuell mit anderer Reihenfolge:

| VorlNr | Titel | PersNr |

|---|---|---|

| 1000 | Softwareentwicklung 1 | 12 |

| 1200 | Netzwerke 1 | 20 |

| 1600 | Algorithmen | 12 |

| 2001 | Datenbanken | 20 |

| 5001 | ET | 12 |

| 5022 | IT | 12 |

| 6045 | DB | 20 |

>>>Löschen von Datensätzen ( DELETE )

`B100`F9d9DELETE FROM Vorlesung`f`b

`B100`F9d9 WHERE PersNr = 12;`f`b

löscht alle Datensätze, für die `B100`F9d9PersNr`f`b den Wert `B100`F9d912`f`b hat.

Ergebnis eines nachfolgenden `B100`F9d9SELECT *`f`b, eventuell in anderer Reihenfolge:

| VorlNr | Titel | PersNr |

|---|---|---|

| 1200 | Netzwerke 1 | 20 |

| 2001 | Datenbanken | 20 |

| 6045 | DB | 20 |

>>>Zusammenfassung von INSERT , UPDATE und DELETE

Verallgemeinert sehen die Änderungsanweisungen wie folgt aus.

`B100`F9d9INSERT`f`b-Anweisung:

`B100`F9d9INSERT INTO Quelle [(Auswahlliste)]`f`b

`B100`F9d9VALUES (Werteliste) | SELECT <Auswahlkriterien>;`f`b

`B100`F9d9UPDATE`f`b-Anweisung:

`B100`F9d9UPDATE Quelle SET Zuweisungsliste`f`b

`B100`F9d9[FROM From-Klausel]`f`b

`B100`F9d9[WHERE Auswahlbedingung];`f`b

`B100`F9d9DELETE`f`b-Anweisung:

`B100`F9d9DELETE FROM Quelle`f`b

`B100`F9d9[WHERE Auswahlbedingung];`f`b

>>Datendefinition

>>>Datenbanktabelle ( CREATE TABLE )

Die `F33f`_`[Datenbanktabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanktabelle]`_`f `B100`F9d9Vorlesung`f`b kann mit der folgenden `F33f`_`[Anweisung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anweisung_(Programmierung)]`_`f erzeugt werden:

`B100`F9d9CREATE TABLE Vorlesung (VorlNr INT NOT NULL PRIMARY KEY, Titel VARCHAR NOT NULL, PersNr NOT NULL, FOREIGN KEY (PersNr) REFERENCES Professor (PersNr));`f`b

In keinem der Felder `B100`F9d9VorlNr`f`b, `B100`F9d9Titel`f`b, `B100`F9d9PersNr`f`b ist der Wert `B100`F9d9NULL`f`b erlaubt. Der `F33f`_`[Fremdschlüssel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fremdschlüssel]`_`f `B100`F9d9PersNr`f`b `F33f`_`[referenziert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Referenz_(Programmierung)]`_`f den `F33f`_`[Primärschlüssel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Primärschlüssel]`_`f `B100`F9d9PersNr`f`b der Tabelle `B100`F9d9Professor`f`b. Damit wird sichergestellt, dass in die Tabelle `B100`F9d9Vorlesung`f`b nur `F33f`_`[Datensätze`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datensätze]`_`f eingefügt werden können, für die der Wert von `B100`F9d9PersNr`f`b in der Tabelle `B100`F9d9Professor`f`b als Primärschlüssel vorkommt (siehe `F33f`_`[referenzielle Integrität`#referenzielle-integrit-t]`_`f).

>>>Datenbankindex ( CREATE INDEX )

Mit der `F33f`_`[Anweisung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anweisung_(Programmierung)]`_`f

`B100`F9d9CREATE INDEX VorlesungIndex`f`b

`B100`F9d9ON Vorlesung (PersNr, Titel);`f`b

kann ein `F33f`_`[Datenbankindex`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbankindex]`_`f für die Tabelle `B100`F9d9Vorlesung`f`b definiert werden, der vom Datenbanksystem bei der Ausführung von Abfragen zur Beschleunigung verwendet werden kann. Ob das sinnvoll ist, entscheidet das Datenbanksystem eigenständig durch komplexe Auswertungen und Analysen für jede Abfrage erneut.

>>>Sicht ( CREATE VIEW )

Eine `F33f`_`[Sicht`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sicht_(Datenbank)]`_`f ist im Wesentlichen ein Alias für eine `F33f`_`[Datenbankabfrage`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbankabfrage]`_`f. Sie kann wie eine `F33f`_`[Datenbanktabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanktabelle]`_`f verwendet werden. Die `F33f`_`[Anweisung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anweisung_(Programmierung)]`_`f

`B100`F9d9 CREATE VIEW Vorlesungssicht AS`f`b

`B100`F9d9 SELECT Vorlesung.VorlNr,`f`b

`B100`F9d9 Vorlesung.Titel,`f`b

`B100`F9d9 Professor.PersNr,`f`b

`B100`F9d9 Professor.Name`f`b

`B100`F9d9 FROM Professor`f`b

`B100`F9d9INNER JOIN Vorlesung`f`b

`B100`F9d9 ON Professor.PersNr = Vorlesung.PersNr;`f`b

speichert die definierte Abfrage als Sicht. Die Abfrage

`B100`F9d9SELECT Titel,`f`b

`B100`F9d9 Name`f`b

`B100`F9d9 FROM Vorlesungssicht`f`b

`B100`F9d9 WHERE VorlNr < 5000;`f`b

verwendet diese `F33f`_`[Sicht`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sicht_(Datenbank)]`_`f und könnte zum Beispiel folgendes Ergebnis liefern:

| Titel | Name |

|---|---|

| Softwareentwicklung 1 | Wirth |

| Netzwerke 1 | Urlauber |

| Algorithmen | Wirth |

| Datenbanken | Urlauber |

>>>Zusammenfassung von CREATE TABLE , CREATE INDEX und CREATE VIEW

Zusammengefasst sind die wichtigsten Elemente der Definition einer `F33f`_`[Datenbanktabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanktabelle]`_`f, eines `F33f`_`[Datenbankindex`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbankindex]`_`f oder einer `F33f`_`[Sicht`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sicht_(Datenbank)]`_`f wie folgt anzugeben:

`B100`F9d9CREATE TABLE Tabellenname (Attributdefinition [PRIMARY KEY]) [, FOREIGN KEY (Attributliste) REFERENCES Tabellenname (Attributliste)]);`f`b

`B100`F9d9DROP TABLE Tabellenname;`f`b

`B100`F9d9ALTER TABLE Tabellenname (Attributdefinition [PRIMARY KEY]) [, FOREIGN KEY (Attributliste) REFERENCES Tabellenname (Attributliste)]);`f`b

`B100`F9d9`f`b

`B100`F9d9CREATE INDEX Indexname ON Tabellenname (Attributliste);`f`b

`B100`F9d9DROP INDEX Indexname;`f`b

`B100`F9d9`f`b

`B100`F9d9CREATE VIEW Sichtname [(Attributliste)] AS SELECT <Auswahlkriterien>;`f`b

`B100`F9d9DROP VIEW Sichtname;`f`b

>>Redundanz

→

Hauptartikel

Normalisierung (Datenbank)

Ein `F33f`_`[Grundsatz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grundsatz]`_`f des `F33f`_`[Datenbankdesigns`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbankdesign]`_`f ist, dass in einer Datenbank keine `F33f`_`[Redundanzen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Redundanz_(Informationstheorie)]`_`f auftreten sollen. Dies bedeutet, dass jede Information, also zum Beispiel eine Adresse, nur genau einmal gespeichert wird.

`*Beispiel`*: in der Teilnehmerliste einer Vorlesung werden die Adressen nicht erneut erfasst, sondern nur indirekt über die Matrikelnummer. Um dennoch eine Teilnehmerliste mit Adressen zu erstellen, erfolgt eine `B100`F9d9SELECT`f`b-Abfrage, in der die Teilnehmertabelle mit der Studententabelle verknüpft wird (siehe oben: `B100`F9d9JOIN`f`b).

In manchen Fällen ist die `F33f`_`[Performance`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rechenleistung]`_`f einer Datenbank besser, wenn sie nicht (vollständig) normalisiert wird. In diesem Falle werden in der Praxis oft Redundanzen bewusst in Kauf genommen, um zeitaufwändige und komplexe `F33f`_`[Joins`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Relationale_Algebra]`_`f zu verkürzen und so die Geschwindigkeit der Abfragen zu erhöhen. Man spricht auch von einer Denormalisierung einer Datenbank. Wann (und ob überhaupt) eine Denormalisierung sinnvoll ist, ist umstritten und hängt von den Umständen ab.

>>Schlüssel

→

Hauptartikel

Schlüssel (Datenbank)

Während die Informationen auf viele Tabellen verteilt werden müssen, um Redundanzen zu vermeiden, sind Schlüssel das Mittel, um diese verstreuten Informationen miteinander zu verknüpfen.

So hat in der Regel jeder Datensatz eine eindeutige Nummer oder ein anderes eindeutiges Feld, um ihn zu identifizieren. Diese Identifikationen werden als Schlüssel bezeichnet.

Wenn dieser Datensatz in anderen Zusammenhängen benötigt wird, wird lediglich sein Schlüssel angegeben. So werden bei der Erfassung von Vorlesungsteilnehmern nicht deren Namen und Adressen, sondern nur deren jeweilige Matrikelnummer erfasst, aus der sich alle weiteren Personalien ergeben.

So kann es sein, dass manche Datensätze nur aus Schlüsseln (meist Zahlen) bestehen, die erst in Verbindung mit Verknüpfungen verständlich werden. Der eigene Schlüssel des Datensatzes wird dabei als Primärschlüssel bezeichnet. Andere Schlüssel im Datensatz, die auf die Primärschlüssel anderer Tabellen verweisen, werden als Fremdschlüssel bezeichnet.

Schlüssel können auch aus einer Kombination mehrerer Angaben bestehen. Zum Beispiel können die Teilnehmer einer Vorlesung durch die eindeutige Kombination von Vorlesungsnummer und Studentennummer identifiziert werden, so dass die doppelte Anmeldung eines Studenten zu einer Vorlesung ausgeschlossen ist.

>>Referenzielle Integrität

→

Hauptartikel

Referentielle Integrität

Referenzielle Integrität bedeutet, dass Datensätze, die von anderen Datensätzen verwendet werden, in der Datenbank auch vollständig vorhanden sind.

Im obigen Beispiel bedeutet dies, dass in der Teilnehmertabelle nur Matrikel-Nummern gespeichert sind, die es in der Studenten-Tabelle auch tatsächlich gibt.

Diese wichtige Funktionalität kann (und sollte) bereits von der Datenbank überwacht werden, so dass zum Beispiel

• nur vorhandene Matrikelnummern in die Teilnehmertabelle eingetragen werden können,

• der Versuch, den Datensatz eines Studenten, der schon eine Vorlesung belegt hat, zu `*löschen`*, entweder verhindert wird (Fehlermeldung) oder der Datensatz auch gleich aus der Teilnehmertabelle entfernt wird (Löschweitergabe) und

• der Versuch, die Matrikelnummer eines Studenten, der schon eine Vorlesung belegt hat, zu `*ändern`*, entweder verhindert wird (Fehlermeldung) oder der Eintrag in der Teilnehmertabelle gleich mitgeändert wird (Aktualisierungsweitergabe).

Widersprüchlichkeit von Daten wird allgemein als `F33f`_`[Dateninkonsistenz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konsistenz_(Datenspeicherung)]`_`f bezeichnet. Diese besteht, wenn Daten bspw. die `F33f`_`[Integritätsbedingungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integritätsbedingung]`_`f (z. B. `F33f`_`[Constraints`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Constraint]`_`f oder `F33f`_`[Fremdschlüsselbeziehungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schlüssel_(Datenbank)]`_`f) nicht erfüllen.

Ursachen für Dateninkonsistenzen können Fehler bei der Analyse des Datenmodells, fehlende `F33f`_`[Normalisierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Normalisierung_(Datenbank)]`_`f des `F33f`_`[ERM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Entity-Relationship-Modell]`_`f oder Fehler in der Programmierung sein.

Zum letzteren gehören die `*`F33f`_`[Lost-Update`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Verlorene_Updates]`_`f`*-Phänomene sowie die Verarbeitung von zwischenzeitlich veralteten Zwischenergebnissen. Dies tritt vor allem bei der Online-Verarbeitung auf, da dem Nutzer angezeigte Werte nicht in einer Transaktion gekapselt werden können.

`B100`F9d9Beispiel:`f`b

`B100`F9d9Transaktion A liest Wert x`f`b

`B100`F9d9Transaktion B verringert Wert x um 10`f`b

`B100`F9d9Transaktion A erhöht den gespeicherten Wert von x um eins und schreibt zurück`f`b

`B100`F9d9Ergebnis x' = x+1`f`b

`B100`F9d9Die Änderung von B ist verloren gegangen`f`b

>>SQL-Datentypen

→

Hauptartikel

Datentypen

In den oben vorgestellten Befehlen `B100`F9d9CREATE TABLE`f`b und `B100`F9d9ALTER TABLE`f`b wird bei der Definition jeder Spalte angegeben, welchen `F33f`_`[Datentyp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f die Werte dieser Spalte annehmen können. Dazu liefert SQL eine ganze Reihe standardisierter Datentypen mit. Die einzelnen DBMS-Hersteller haben diese Liste jedoch um eine Unzahl weiterer Datentypen erweitert. Die wichtigsten Standarddatentypen sind:

`!`B100`F9d9INTEGER`f`b`!

`F33f`_`[Ganze Zahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ganze_Zahl]`_`f (positiv oder negativ), wobei je nach Zahl der verwendeten Bits Bezeichnungen wie `B100`F9d9SMALLINT`f`b, `B100`F9d9TINYINT`f`b oder `B100`F9d9BIGINT`f`b verwendet werden. Die jeweiligen Grenzen und die verwendete Terminologie sind vom Datenbanksystem definiert.

`!`B100`F9d9NUMERIC (n, m)`f`b oder `B100`F9d9DECIMAL (n, m)`f`b`!

`F33f`_`[Festkommazahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Festkommazahl]`_`f (positiv oder negativ) mit insgesamt maximal `B100`F9d9n`f`b Stellen, davon `B100`F9d9m`f`b Nachkommastellen. Wegen der hier erfolgenden Speicherung als Dezimalzahl ist eine besonders für Geldbeträge notwendige Genauigkeit gegeben.

`!`B100`F9d9FLOAT (m)`f`b`!

`F33f`_`[Gleitkommazahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Gleitkommazahl]`_`f (positiv oder negativ) mit maximal `B100`F9d9m`f`b Nachkommastellen.

`!`B100`F9d9REAL`f`b`!

`F33f`_`[Gleitkommazahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Gleitkommazahl]`_`f (positiv oder negativ). Die Genauigkeit für diesen Datentyp ist jeweils vom Datenbanksystem definiert.

`!`B100`F9d9DOUBLE`f`b oder `B100`F9d9DOUBLE PRECISION`f`b`!

`!`B100`F9d9FLOAT`f`b und `B100`F9d9DOUBLE`f`b`!

sind für technisch-wissenschaftliche Werte geeignet und umfassen auch die Exponentialdarstellung. Wegen der Speicherung im Binärformat sind sie aber für Geldbeträge nicht geeignet, weil sich beispielsweise der Wert 0,10 € (entspricht 10 Cent) nicht exakt abbilden lässt.

`!`B100`F9d9CHARACTER (n)`f`b oder `B100`F9d9CHAR (n)`f`b`!

`F33f`_`[Zeichenkette`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeichenkette]`_`f Text mit `B100`F9d9n`f`b Zeichen.

`!`B100`F9d9VARCHAR (n)`f`b oder `B100`F9d9CHARACTER VARYING (n)`f`b`!

Zeichenkette (also Text) von variabler Länge, aber maximal `B100`F9d9n`f`b druckbaren und/oder nicht druckbaren Zeichen. Die Variante `B100`F9d9VARCHAR2`f`b ist für `F33f`_`[Oracle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oracle_(Datenbanksystem)]`_`f spezifisch, ohne dass sie sich tatsächlich unterscheidet.

`!`B100`F9d9TEXT`f`b`!

Zeichenkette (zumindest theoretisch) beliebiger Länge. In manchen Systemen synonym zu `B100`F9d9CLOB`f`b.

`!`B100`F9d9DATE`f`b`!

Datum (ohne Zeitangabe)

`!`B100`F9d9TIME`f`b`!

Zeitangabe (evtl. inklusive Zeitzone)

`!`B100`F9d9TIMESTAMP`f`b`!

Zeitstempel (umfasst Datum und Uhrzeit; evtl. inklusive Zeitzone), meistens mit Millisekundenauflösung, teilweise auch mikrosekundengenau

`!`B100`F9d9BOOLEAN`f`b`!

`F33f`_`[Boolesche Variable`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Boolesche_Variable]`_`f (kann die Werte `B100`F9d9true`f`b(wahr) oder `B100`F9d9false`f`b (falsch) oder `B100`F9d9NULL`f`b (unbekannt) annehmen). Dieser Datentyp ist laut SQL:2003 optional und nicht alle DBMS stellen diesen Datentyp bereit.

`!`B100`F9d9`F33f`_`[BLOB`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Binary_Large_Object]`_`f (n)`f`b oder `B100`F9d9BINARY LARGE OBJECT (n)`f`b`!

Binärdaten von maximal `B100`F9d9n`f`b `F33f`_`[Bytes`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Byte]`_`f Länge.

`!`B100`F9d9`F33f`_`[CLOB`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Character_Large_Object]`_`f (n)`f`b oder `B100`F9d9CHARACTER LARGE OBJECT (n)`f`b`!

Zeichenketten mit maximal `B100`F9d9n`f`b Zeichen Länge.

Wenn es die Tabellendefinition erlaubt, können Attribute auch den Wert `B100`F9d9NULL`f`b annehmen, wenn kein Wert bekannt ist oder aus anderen Gründen kein Wert gespeichert werden soll. Der `B100`F9d9NULL`f`b-Wert ist von allen anderen möglichen Werten des Datentyps verschieden.

>>Transaktion, Commit und Rollback

→

Hauptartikel

Transaktion (Informatik)

Eine Transaktion bezeichnet eine Menge von Datenbankänderungen, die zusammen ausgeführt werden (müssen). So ist beispielsweise die Buchung (als Transaktion) eines Geldbetrags durch zwei atomare Datenbankoperationen „Abbuchen des Geldbetrages von Konto A“ und „Buchung des Geldbetrages auf Konto B“ gekennzeichnet. Kann die vollständige Abarbeitung der elementaren Datenbankoperationen der Transaktion nicht durchgeführt werden (z. B. aufgrund eines Fehlers), müssen alle durchgeführten Änderungen an dem Datenbestand auf den Ausgangszustand zurückgesetzt werden.

Der Vorgang, der alle Änderungen einer Transaktion zurücksetzt, wird als Rollback bezeichnet. Der Begriff Commit bezeichnet das Ausführen einer Transaktion. Transaktionen sind eine Möglichkeit, die Konsistenz des Datenbestandes zu sichern. Im Beispiel der doppelten Kontenführung wird durch das Verhindern von ungültigen Teilbuchungen eine ausgeglichene Kontobilanz gewährleistet.

Datenbanken erlauben es zum Teil, bestimmte Befehle außerhalb einer Transaktion auszuführen. Darunter fällt insbesondere das Laden von Daten in Tabellen oder das Exportieren von Daten mittels Utilities. Manche `F33f`_`[DBMS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DBMS]`_`f erlauben das temporäre Abschalten der Transaktionslogik sowie einiger Kontrollen zur Erhöhung der Verarbeitungsgeschwindigkeit. Dies muss allerdings meist durch einen expliziten Befehl erzwungen werden, um ein versehentliches Ändern von Daten außerhalb einer Transaktion zu vermeiden. Solche Änderungen können, falls eine Datenbankwiederherstellung erforderlich ist, zu schweren Problemen oder gar Datenverlusten führen. Eine Transaktion wird mit der SQL-Anweisung `B100`F9d9`F33f`_`[COMMIT`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Commit]`_`f`f`b beendet. Alle Änderungen der Transaktion werden `F33f`_`[persistent`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Persistenz_(Informatik)]`_`f gemacht, und das DBMS stellt durch geeignete (interne) Mittel (z. B. Logging) sicher, dass diese Änderungen nicht verloren gehen.

Mit dem Befehl `B100`F9d9`F33f`_`[ROLLBACK`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rollback]`_`f`f`b wird eine Transaktion ebenfalls beendet, es werden jedoch alle Änderungen seit Beginn der Transaktion rückgängig gemacht. Das heißt, der Zustand des Systems (in Bezug auf die Änderungen der Transaktion) ist der gleiche wie vor der Transaktion.

>>Programmieren mit SQL

>>>Programmierschnittstelle

Das ursprüngliche SQL war keine `F33f`_`[Turing-vollständige`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Turing-Vollständigkeit]`_`f `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f, es ermöglichte also nicht die Realisierung von beliebigen `F33f`_`[Computerprogrammen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f. Mittlerweile lässt es sich mit anderen Programmiersprachen kombinieren, um eine `F33f`_`[Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierung]`_`f im engeren Sinne zu ermöglichen. Hierfür gibt es unterschiedliche Techniken.

• Mit `F33f`_`[Embedded SQL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Embedded_SQL]`_`f können SQL-Anweisungen im Quelltext eines Programms, typischerweise in `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f, `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f, `F33f`_`[COBOL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=COBOL]`_`f, `F33f`_`[Ada`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ada_(Programmiersprache)]`_`f, `F33f`_`[Pascal`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Pascal_(Programmiersprache)]`_`f o. Ä. geschrieben, eingebettet werden. Während der Programmvorbereitung übersetzt ein `F33f`_`[Precompiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Precompiler]`_`f die SQL-Befehle in Funktionsaufrufe. Embedded SQL ist Teil des ANSI-SQL-Standards. Beispiele für Implementierungen: `F33f`_`[SQLJ`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQLJ]`_`f für `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f, `F33f`_`[Pro*C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Pro*C]`_`f für `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f, C++, `F33f`_`[ADO`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ActiveX_Data_Objects]`_`f und `F33f`_`[ADO.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ADO.NET]`_`f.

• Herkömmliche `*`F33f`_`[Programmierschnittstellen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierschnittstelle]`_`f`* erlauben die direkte Übergabe von SQL-Befehlen an Datenbanksysteme über Funktionsaufrufe. Beispiele: `F33f`_`[ODBC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ODBC]`_`f, `F33f`_`[JDBC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_Database_Connectivity]`_`f, `F33f`_`[ADO`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ActiveX_Data_Objects]`_`f.

• `F33f`_`[Persistenz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Persistenz_(Informatik)]`_`f-`F33f`_`[Frameworks`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Framework]`_`f wie etwa `F33f`_`[Hibernate`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hibernate_(Framework)]`_`f oder `F33f`_`[iBATIS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IBATIS]`_`f abstrahieren vom Datenbankzugriff und ermöglichen `F33f`_`[objektorientierte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f Verarbeitung von relationalen Datenbanken in einer objektorientierten Programmiersprache (z. B. `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f oder `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f)

• Mit dem Teil 4 `*SQL/PSM`* des Standards werden Konstrukte wie IF-Blöcke und Schleifen bereitgestellt. Er wird in den Datenbanksystemen in unterschiedlicher Ausprägung und mit Hersteller-spezifischen Erweiterungen implementiert, z. B. `F33f`_`[PL/SQL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PL/SQL]`_`f in `F33f`_`[Oracle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oracle_(Datenbanksystem)]`_`f oder `F33f`_`[Transact-SQL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Transact-SQL]`_`f im `F33f`_`[MS SQL Server`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_SQL_Server]`_`f.

>>>Statisches und dynamisches SQL

Unabhängig von der verwendeten Programmiertechnik wird zwischen `*statischem`* und `*dynamischem`* SQL unterschieden.

• Bei `*statischem SQL`* ist die SQL-Anweisung dem Datenbanksystem zum Zeitpunkt der Programmübersetzung bekannt und festgelegt (z. B. wenn die Abfrage eines Kontos vorformuliert ist und zur Laufzeit nur die Kontonummer eingesetzt wird).

• Bei `*dynamischem SQL`* ist die SQL-Anweisung dem Datenbanksystem erst zum Zeitpunkt der Programmausführung bekannt (z. B. weil der Benutzer die komplette Abfrage eingibt). So sind z. B. alle SQL-Anweisungen, die mittels SQL/CLI oder `F33f`_`[JDBC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JDBC]`_`f ausgeführt werden grundsätzlich dynamisch. Ausgeführt werden dynamische SQL-Anweisungen im Allgemeinen mit execute immediate (`*SQL-String`*).

Bei dynamischem SQL `*muss`* das Datenbanksystem die SQL-Anweisung zur Laufzeit des Programms interpretieren und den Zugriffspfad optimieren. Da dieser sogenannte Parse-Vorgang Zeit in Anspruch nimmt, puffern viele Datenbanksysteme die bereits geparsten SQL-Anweisungen, um mehrfaches Parsen gleicher Abfragen zu vermeiden. Bei statischem SQL `*kann`* schon bei der Übersetzung der Programme bzw. beim Binden der SQL-Anweisungen an eine Datenbank (sogenanntes `*Bind`* der SQL-Befehle) der optimale Zugriffsweg bestimmt werden. Damit sind kürzestmögliche Laufzeiten der Anwendungsprogramme möglich, allerdings muss der Zugriffsweg aller betroffenen Programme neu bestimmt werden, wenn sich Voraussetzungen (z. B. Statistiken) ändern (`*Rebind`*). Die `*Bind`*-Phase ist heute vor allem im `F33f`_`[Großrechner`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Großrechner]`_`f-Umfeld bekannt, die meisten Datenbanksysteme optimieren hingegen zur Laufzeit.

>>Chronologie

• etwa 1975: `*SEQUEL`* = `*Structured English Query Language`*, der Vorläufer von `*SQL`*, wird für das Projekt `F33f`_`[System R`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=System_R]`_`f von `F33f`_`[IBM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IBM]`_`f entwickelt.

• 1979: `*SQL`* gelangt mit `*Oracle V2`* erstmals durch `*Relational Software Inc.`* auf den Markt.

• 1986: `*SQL1`* wird von `F33f`_`[ANSI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=American_National_Standards_Institute]`_`f als Standard verabschiedet.

• 1987: `*SQL1`* wird von der `F33f`_`[Internationalen Organisation für Normung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internationale_Organisation_für_Normung]`_`f (ISO) als Standard verabschiedet und 1989 nochmals überarbeitet.

• 1992: Der Standard `*SQL2`* oder `*SQL-92`* wird von der ISO verabschiedet.

• 1999: `*SQL3`* oder `*SQL:1999`* wird verabschiedet. Im Rahmen dieser Überarbeitung werden weitere wichtige Features (wie etwa `F33f`_`[Trigger`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenbanktrigger]`_`f oder rekursive Abfragen) hinzugefügt.

• 2003: `*SQL:2003`*. Als neue Features werden aufgenommen `F33f`_`[SQL/XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQL/XML]`_`f, Window functions, Sequences.

• 2006: `*SQL/XML:2006`*. Erweiterungen für `F33f`_`[SQL/XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQL/XML]`_`f`:cite-ref-sqlxml2006-2-0[`F5bf`_`[2`#cite-note-sqlxml2006-2]`_`f].

• 2008: `*SQL:2008`* bzw. ISO/IEC 9075:2008. Als neue Features werden aufgenommen INSTEAD OF-Trigger, TRUNCATE-Statement und FETCH-Klausel.

• 2011: `*SQL:2011`* bzw. ISO/IEC 9075:2011. Als neue Features werden aufgenommen „Zeitbezogene Daten“ (PERIOD FOR). Es gibt Erweiterungen für Window functions und die FETCH-Klausel.

• 2016: `*SQL:2016`* bzw. ISO/IEC 9075:2016. Als neue Features werden aufgenommen JSON und „row pattern matching“.

• 2019: `*SQL/MDA:2019`*. Erweiterungen für einen Datentyp „mehrdimensionales Feld“.

>>Sprachstandard

Ziel der Standardisierung ist es, `F33f`_`[Anwendungsprogramme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anwendungsprogramm]`_`f so erstellen zu können, dass sie vom verwendeten Datenbanksystem unabhängig sind. Heutige Datenbanksysteme `F33f`_`[implementieren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Implementierung]`_`f mehr oder weniger große Teile des Sprachstandards. Darüber hinaus stellen sie oftmals herstellerspezifische Erweiterungen bereit, die nicht dem Standard-Sprachumfang entsprechen. In der Vor-SQL-Zeit strebte man die Portabilität von Anwendungen über die `F33f`_`[kompatible Schnittstelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kompatible_Schnittstellen]`_`f an.

Der Standard besteht insgesamt aus zehn einzelnen Publikationen:`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]

• ISO/IEC 9075-1:2016 Part 1: Framework (SQL/Framework)

• ISO/IEC 9075-2:2016 Part 2: Foundation (SQL/Foundation)

• ISO/IEC 9075-3:2016 Part 3: Call-Level Interface (SQL/CLI)

• ISO/IEC 9075-4:2016 Part 4: Persistent stored modules (SQL/PSM)

• ISO/IEC 9075-9:2016 Part 9: Management of External Data (SQL/MED)

• ISO/IEC 9075-10:2016 Part 10: Object language bindings (`F33f`_`[SQL/OLB`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQLJ]`_`f)

• ISO/IEC 9075-11:2016 Part 11: Information and definition schemas (SQL/Schemata)

• ISO/IEC 9075-13:2016 Part 13: SQL Routines and types using the Java TM programming language (SQL/JRT)

• ISO/IEC 9075-14:2016 Part 14: XML-Related Specifications (`F33f`_`[SQL/XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQL/XML]`_`f)

• ISO/IEC 9075-15:2019 Part 15: Multi-dimensional arrays (SQL/MDA)

Ein weiterer Teil befindet sich derzeit (2019) in Entwicklung:

• ISO/IEC 9075-16:20xx Part 16: Property Graph Queries (SQL/PGQ)

Der Standard wird durch sechs, ebenfalls standardisierte `*SQL multimedia and application packages`* ergänzt:

• ISO/IEC 13249-1:2016 Part 1: Framework

• ISO/IEC 13249-2:2003 Part 2: Full-Text

• ISO/IEC 13249-3:2016 Part 3: Spatial

• ISO/IEC 13249-5:2003 Part 5: Still image

• ISO/IEC 13249-6:2006 Part 6: Data mining

• ISO/IEC 13249-7:2013 Part 7: History

Weiterhin existieren eine Reihe Technical Reports, die eine Einführung zu den einzelnen Themen bieten.

• ISO/IEC TR 19075-1:2011 Part 1: XQuery Regular Expression Support in SQL`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]

• ISO/IEC TR 19075-2:2015 Part 2: SQL Support for Time-Related Information`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f]

• ISO/IEC TR 19075-3:2015 Part 3: SQL Embedded in Programs using the JavaTM programming language`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]

• ISO/IEC TR 19075-4:2015 Part 4: SQL with Routines and types using the JavaTM programming language`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]

• ISO/IEC TR 19075-5:2016 Part 5: Row Pattern Recognition in SQL`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f]

• ISO/IEC TR 19075-6:2017 Part 6: SQL support for JavaScript Object Notation (JSON)`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f]

• ISO/IEC TR 19075-7:2017 Part 7: Polymorphic table functions in SQL`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f]

• ISO/IEC TR 19075-8:2019 Part 8: Multi-dimensional arrays (SQL/MDA) (wurde zurückgezogen`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f])

Ein weiterer Teil befindet sich derzeit (2019) in Entwicklung:

• ISO/IEC TR 19075-9:20xx Part 9: Online Analytic Processing (OLAP) capabilities

Der offizielle Standard ist nicht frei verfügbar, jedoch existiert ein Zip-Archiv mit einer Arbeitsversion von 2008.`:cite-ref-12[`F5bf`_`[12`#cite-note-12]`_`f] Die Technical Reports sind kostenlos von ISO erhältlich.

>>Erweiterungen

Die beiden ersten Teile des SQL Standards `*SQL/Framework`* und `*SQL/Foundation`* legen die Kernfunktionalitäten fest. In den weiteren Teilen werden spezifische Aspekte der Sprache definiert.

• Teil 4: Bei `*SQL/PSM`* handelt es sich um die Erweiterung um prozedurale Konstrukte. Sie ermöglichen unter anderem das Programmieren von Schleifen (FOR, WHILE, REPEAT UNTIL, LOOP), Cursorn, Exception-Handling, Triggern und eigenen Funktionen. Oracle implementiert diese Funktionalität unter dem Namen `*`F33f`_`[PL/SQL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PL/SQL]`_`f`*, DB2 verwendet den Begriff `*SQL/PL`*, PostgreSQL nennt es `*`F33f`_`[PL/pgSQL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PL/pgSQL]`_`f`*.

• Teil 14: `*`F33f`_`[SQL/XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQL/XML]`_`f`* ermöglicht es, `F33f`_`[XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Extensible_Markup_Language]`_`f-Dokumente in SQL-Datenbanken zu speichern, mit `F33f`_`[XPath`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=XPath]`_`f in SQL/XML:2003 und `F33f`_`[XQuery`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=XQuery]`_`f ab SQL/XML:2006 abzufragen und relationale Datenbankinhalte als XML zu exportieren. Um die ursprünglichen Arbeiten an diesem Teil des Standards zu beschleunigen, hatte sich im Jahr 2000 eine informelle Arbeitsgruppe gebildet (IBM, Oracle, …), die unter dem Namen `*The SQLX Group`* und unter der Bezeichnung `*SQLX`* die Kernfunktionalitäten festlegte. Deren Arbeit ist in den jetzigen Standard eingeflossen.

Als Ergänzung zum SQL-Standard existiert mit `*ISO/IEC 13249: SQL multimedia and application packages`* eine Norm, die für die Anwendungsfälle `*Text`*, `*Geografische Daten`*, `*Bilder`*, `*Data mining`* und `*Metadaten`* spezialisierte Schnittstellen in SQL Syntax festlegt.

>>Literatur

• Donald D. Chamberlin, Raymond F. Boyce: `*SEQUEL: A Structured English Query Language`*. In: `*SIGMOD Workshop.`* Vol. 1 1974, S. 249–264.

• Donald D. Chamberlin, Morton M. Astrahan, Kapali P. Eswaran, Patricia P. Griffiths, Raymond A. Lorie, James W. Mehl, Phyllis Reisner, Bradford W. Wade: `*SEQUEL 2: A Unified Approach to Data Definition, Manipulation, and Control`*. In: `*IBM Journal of Research and Development.`* 20(6) 1976, S. 560–575.

• Günter Matthiessen, Michael Unterstein: `*Relationale Datenbanken und SQL in Theorie und Praxis`* Springer Vieweg, ISBN 978-3-642-28985-9.

• Edwin Schicker: `*Datenbanken und SQL – Eine praxisorientierte Einführung.`* Teubner, ISBN 3-519-02991-X.

• Oliver Bartosch, Markus Throll: `*Einstieg in SQL.`* Galileo Press, ISBN 3-89842-497-9.

• Daniel Warner, Günter Leitenbauer: `*SQL.`* Franzis, ISBN 3-7723-7527-8.

• H. Faeskorn-Woyke, B. Bertelsmeier, P. Riemer, E. Bauer: `*Datenbanksysteme, Theorie und Praxis mit SQL2003, Oracle und MySQL.`* Pearson-Studium, ISBN 978-3-8273-7266-6.

• Jörg Fritze, Jürgen Marsch: `*Erfolgreiche Datenbankanwendung mit SQL3. Praxisorientierte Anleitung – effizienter Einsatz – inklusive SQL-Tuning.`* Vieweg Verlag, ISBN 3-528-55210-7.

• Can Türker: `*SQL 1999 & SQL 2003.`* Dpunkt Verlag, ISBN 3-89864-219-4.

• Gregor Kuhlmann, Friedrich Müllmerstadt: `*SQL.`* Rowohlt, ISBN 3-499-61245-3.

• Michael J. Hernandez, John L. Viescas: `*Go To SQL.`* Addison-Wesley, ISBN 3-8273-1772-X.

• `F33f`_`[A. Kemper`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Alfons_Kemper]`_`f, A. Eickler: `*Datenbanksysteme – Eine Einführung.`* Oldenbourg, ISBN 3-486-25053-1.

• Marcus Throll, Oliver Bartosch: `*Einstieg in SQL 2008.`* 2. Auflage. Galileo Computing, ISBN 978-3-8362-1039-3 inklusive Übungssoftware SQL-Teacher

• Marco Skulschus: `*SQL und relationale Datenbanken`* Comelio Medien, ISBN 978-3-939701-11-8.

• Michael Wagner: `*SQL/XML:2006 – Evaluierung der Standardkonformität ausgewählter Datenbanksysteme`* 1. Auflage. Diplomica Verlag, ISBN 3-8366-9609-6.

• Christian F. G. Schendera: `*SQL mit SAS. Band 1: PROC SQL für Einsteiger`*. Oldenbourg Wissenschaftsverlag, München 2011, ISBN 978-3-486-59840-7.

• Christian F. G. Schendera: `*SQL mit SAS. Band 2: Fortgeschrittenes PROC SQL`*. Oldenbourg Wissenschaftsverlag, München 2012, ISBN 978-3-486-59836-0.

• `F33f`_`[C. J. Date`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Christopher_J._Date]`_`f, `F33f`_`[Hugh Darwen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hugh_Darwen]`_`f: `*A Guide to the SQL standard: a users guide to the standard database language SQL, 4th ed.`*, Addison-Wesley, USA 1997, ISBN 978-0-201-96426-4

• Jim Melton: `*Advanced SQL:1999: Understanding Object-Relational and Other Advanced Features, 1st ed.`*, Morgan Kaufmann, USA, 2002, ISBN 978-1558606777.

>>Weblinks

Wikibooks: SQL

– Lern- und Lehrmaterialien

• Erklärvideos zu SQL, Big Data Analytics Group, Uni Saarland

• Linkkatalog zum Thema SQL bei `*curlie.org`* (ehemals `F33f`_`[DMOZ`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DMOZ]`_`f)

• SQL-Grundlagen – Einführung mit Beispielen und Vergleich diverser Datenbanken

• Merkblatt SQL

• The 1995 SQL Reunion: People, Projects, and Politics – zur frühen Geschichte von SQL (englisch)

• Frei verfügbare SQL-Standard-Dokumente, z. B. SQL:2003 und SQL:2008 (englisch)

• SQL-Tutorial

• GNU SQLTutor

• SQLcoach – Freies Üben von SQL

• Interaktiver SQL-Trainer (Anmeldung notwendig)

• Blogbeitrag zu SQL-Befehlen und deren Einsatz in PHP

• SQL Tuning

• Transact-SQL Reference (Database Engine)

>>Siehe auch

• `F33f`_`[SQL-Injection`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SQL-Injection]`_`f

• `F33f`_`[SchemaSQL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SchemaSQL]`_`f

• `F33f`_`[Continuous Query Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Continuous_Query_Language]`_`f

• `F33f`_`[Liste der Datenbankmanagementsysteme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Liste_der_Datenbankmanagementsysteme]`_`f

• `F33f`_`[Bereichsabfrage`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bereichsabfrage]`_`f

>>Weblinks

Wiktionary: SQL

– Bedeutungserklärungen, Wortherkunft, Synonyme, Übersetzungen

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f `*Diskussion über System R und zur Namensänderung von SEQUEL zu SQL`*

`:cite-note-sqlxml2006-2`!2.`! `F0af`_`[↑`#cite-ref-sqlxml2006-2-0]`_`f Michael Wagner: SQL/XML:2006 – Evaluierung der Standardkonformität ausgewählter Datenbanksysteme. Diplomica Verlag, 2010, ISBN 3-8366-9609-6, S. 100.

`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f `*ISO/IEC 9075 und 13249.`* International Organization for Standardization, abgerufen am 20. September 2018 (englisch).

`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f ISO/IEC TR 19075-1:2011 Part 1: XQuery Regular Expression Support in SQL

`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f ISO/IEC TR 19075-2:2015 Part 2: SQL Support for Time-Related Information

`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f ISO/IEC TR 19075-3:2015 Part 3: SQL Embedded in Programs using the JavaTM programming language

`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f ISO/IEC TR 19075-4:2015 Part 4: SQL with Routines and types using the JavaTM programming language

`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f ISO/IEC TR 19075-5:2016 Part 5: Row Pattern Recognition in SQL

`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f ISO/IEC TR 19075-6:2017 Part 6: SQL support for JavaScript Object Notation (JSON)

`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f ISO/IEC TR 19075-7:2017 Part 7: Polymorphic table functions in SQL

`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f `*ISO/IEC TR 19075-8:2019.`* In: `*iso.org.`* Abgerufen am 24. August 2022 (englisch).

`:cite-note-12`!12.`! `F0af`_`[↑`#cite-ref-12]`_`f Arbeitsversion des Standards von 2008 (`F33f`_`[ZIP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ZIP-Dateiformat]`_`f; 12,7 MB)

`c`F0af`_`[↑ Back to top`#top]`_`f`a